home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / Drtf / DRTFHandler.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  44.5 KB  |  2,541 lines  |  [TEXT/R*ch]
  1. // DRTFHandler.cpp
  2. // d.g.gilbert
  3.  
  4.  
  5. #include "Dvibrant.h"
  6. #include "DFile.h"
  7. #include "DRTFHandler.h"
  8. #include "DRichProcess.h"
  9. #include "DRichViewNu.h"
  10.  
  11.  
  12.  
  13. # define    rtfInternal
  14. #define STDARG
  15. # include    "rtf.h"
  16. # undef        rtfInternal
  17.  
  18.  
  19.  
  20. enum {
  21.     RTFBreakInData = -6,        // mark end of data buffer, but not EOF 
  22.     chPictTag = 26,
  23.     kWaitTables = DRichHandler::kAtEnd + 1
  24.      };
  25.      
  26.      
  27. class DRTFprocess : public DRichprocess
  28. {
  29. public:
  30.     static void RTFWriterInit(char* mapfilepath, char* charMapFile, char* symMapFile);
  31.     static void RTFWriterEnd();
  32.  
  33.     DRTFprocess( DFile* itsFile, DRichView* itsDoc, Nlm_MonitorPtr progress);
  34.     virtual ~DRTFprocess();
  35.  
  36.     short GetToken(); // temp override
  37.     void  RouteToken(); // temp override
  38.     void  SetToken();
  39.     
  40.     void    handleTextClass();
  41.     void    handleControlClass(); 
  42.     void  handleGroupClass();
  43.  
  44. protected:
  45.     char*     fPict;
  46.     ulong     fPictMax, fPictSize;
  47.     long         fPicNibble;
  48.     short     fLastNibble, fPictKind;
  49.     Boolean    fInPic, fGlobalsInUse;
  50.     
  51.     void  PutPicChar(short c);
  52.     void  PutStdChar(short stdCode);
  53.  
  54.   void  Destination();
  55.   void  SpecialChar();
  56.   void  DocAttr();
  57.   void  SectAttr();
  58.   void  TblAttr();
  59.   void  ParAttr();
  60.   void  CharAttr();
  61.   void  PictAttr();
  62.   void  BookmarkAttr();
  63.   void  NeXTGrAttr();
  64.   void  FieldAttr();
  65.   void  TOCAttr();
  66.   void  PosAttr();
  67.   void  ObjAttr();
  68.   void  FNoteAttr();
  69.   void  KeyCodeAttr();
  70.   void  ACharAttr();
  71.   void  FontAttr();
  72.   void  FileAttr();
  73.   void  FileSource();
  74.   void  DrawAttr();
  75.   void  IndexAttr();
  76.   void  SelectLanguage();
  77. };
  78.  
  79.  
  80.  
  81. //class DRTFsetup
  82.  
  83. static char* kRTFgenmap = "show-gen";
  84. static char* kRTFsymmap = "show-sym";
  85. static char* kRTFfolder = "rtf-maps";
  86.  
  87. class DRTFsetup  
  88. {
  89. public:
  90.     DRTFsetup();
  91.     ~DRTFsetup();
  92. };
  93.  
  94. static DRTFsetup* gRTFsetup = NULL;
  95.  
  96. #if 0
  97. static DRTFsetup  rtfSetup; // initialize here
  98. #endif
  99.  
  100. DRTFsetup::DRTFsetup()
  101. {
  102.     char *progpath;
  103.     
  104.     progpath= (char*) DFileManager::GetProgramPath();  
  105.     progpath= (char*) DFileManager::PathOnlyFromPath( progpath);
  106.     progpath= (char*) DFileManager::BuildPath( progpath, kRTFfolder, NULL);
  107.     // progpath so far is all stored in DFileManager static var
  108.     // progpath= StrDup( progpath);
  109.     DRTFprocess::RTFWriterInit(progpath, kRTFgenmap, kRTFsymmap);        // once-only writer initialization 
  110.     //MemFree(progpath);
  111. }
  112.  
  113. DRTFsetup::~DRTFsetup()
  114. {
  115.     DRTFprocess::RTFWriterEnd();            // once-only writer cleanup 
  116. }
  117.  
  118.  
  119.  
  120.  
  121. //class  DRTFHandler
  122.  
  123. DRTFHandler::DRTFHandler(DRichView* itsDoc, DFile* savefile) :
  124.     DRichHandler( itsDoc, savefile)
  125. {
  126.     fFormatName = "RTF";
  127.     fMinDataToProcess= 128; // no fixed min, need to look at data...
  128.   if (gRTFsetup==NULL) gRTFsetup= new DRTFsetup();
  129. }
  130.  
  131. char* DRTFHandler::IsRich(char* buf, ulong buflen)
  132. {
  133.     if (buflen==0) buflen= strlen(buf);
  134.     ulong len = buflen;
  135.     while (len>3) {
  136.         char* cp= (char*) MemChr(buf,'{',len);
  137.         if (!cp)
  138.             return NULL;        
  139.         else if (cp[1] == '\\' && cp[2] == 'r' && cp[3] == 't' && cp[4] == 'f') 
  140.             return cp;
  141.         else {
  142.             cp++;
  143.             len -= (cp - buf);
  144.             buf = cp;
  145.             }
  146.         }
  147.     return NULL;
  148. }
  149.  
  150.  
  151. DRichprocess* DRTFHandler::NewProcessor( DFile* itsFile, Nlm_MonitorPtr progress)
  152. {
  153.         fProcessor = new DRTFprocess( itsFile, fDoc, progress);
  154.         return fProcessor;
  155. }
  156.  
  157. Boolean DRTFHandler::ProcessData( char* cbeg, char* cend, Boolean endOfData, 
  158.                     ulong& dataRemaining) 
  159. {
  160.  
  161.     char  * cp;
  162.     //char csave = 0;  
  163.     //ulong clen;
  164.  
  165.     //return DRichHandler::ProcessData( cbeg, cend, endOfData, dataRemaining);        
  166.  
  167.     
  168.         // RTFRouteToken() is failing in stylesheets because it 
  169.         // calls RTFGetToken when we have no more !!!...
  170.         // ReadStyleSheet, ReadColorTbl, ReadFontTbl all call RTFGetToken !!!
  171.         // need to patch this to parse the RTF for {\fonttbl...}{\colortbl...}{\stylesheet...} 
  172.         // and read until they are all collected !? (at top of \rtf file)
  173.         
  174.     if (fProcessStage == kAtStart && !endOfData) {  
  175.         // patch to wait for {\fonttbl...}{\colortbl...}{\stylesheet...}
  176.         // assume \stylesheet always last ?!
  177.         Nlm_Uint4    foundat = 0;
  178.         Boolean     found = Nlm_StrngPos(cbeg, "{\\stylesheet", 0, false, &foundat);
  179.         if (!found) 
  180.             return false; // wait for more data ...
  181.         else {
  182.             Boolean notdone= true;
  183.             short level= 1;
  184.             cp= cbeg + foundat + 12;
  185.             while (cp < cend && notdone) {
  186.                 cp++;
  187.                 if (*cp == '{') level++;
  188.                 else if (*cp == '}') { level--; if (level<0) notdone= false; }
  189.                 }    
  190.             if (notdone) return false; // wait for more data ...
  191.             }
  192.         }
  193.          
  194.     cp= cend; 
  195.     
  196.     if (!endOfData) while (cp - cbeg > fLastScanto && *cp != '}') cp--;
  197.     if (cp - cbeg <= fLastScanto) {
  198.         fLastScanto= cend - cbeg;  
  199.         if (!endOfData) return false; // !??! don't process unterminated rtf block
  200.         else cp= cend; 
  201.         }
  202.  
  203.     if (*cp) cp++;
  204.     fcsave= *cp; 
  205.     *cp= 0;
  206.     fclen= cp - cbeg; // ?? +1
  207.     
  208.     if (fclen && fDocFile) {
  209.         //fclen= cp - cbeg;
  210.         if (cbeg[fclen-1] == 0) fclen--;
  211.         fDocFile->WriteData( cbeg, fclen);
  212.         }    
  213.  
  214.     return this->ProcessData2( cp, cbeg, cend, endOfData, dataRemaining);
  215. }
  216.  
  217.  
  218.  
  219.  
  220.  
  221.  
  222.  
  223. //class  DRTFprocess
  224.  
  225. //static char        gGenCharMap[rtfSC_MaxChar];
  226. //static char        gSymCharMap[rtfSC_MaxChar];
  227. //static char * gOutMap = gGenCharMap;
  228. static char    * gMapfilePath = NULL;
  229.  
  230. // !! DAMN, we can't deal with this kind of global && multiple processors
  231.  
  232. DRTFprocess* gRTFprocess = NULL;
  233.  
  234.  
  235. extern "C" void rtfHandleUnknownClass()
  236. {
  237.     gRTFprocess->SetToken();
  238.     gRTFprocess->handleUnknownClass();
  239. }
  240.  
  241. extern "C" void rtfHandleTextClass()
  242. {
  243. #if 0 //x
  244.     gRTFprocess->SetToken();
  245. #else
  246.     // inline for speed here...
  247.     gRTFprocess->fClass= rtfClass; 
  248.     gRTFprocess->fMajor= rtfMajor;
  249.     gRTFprocess->fMinor= rtfMinor;
  250.     gRTFprocess->fParam= rtfParam;
  251. #endif
  252.  
  253.     gRTFprocess->handleTextClass();
  254. }
  255.  
  256. extern "C" void rtfHandleControlClass()
  257. {
  258.     gRTFprocess->SetToken();
  259.     gRTFprocess->handleControlClass();
  260. }
  261.  
  262. extern "C" void rtfHandleGroupClass()
  263. {
  264.     gRTFprocess->SetToken();
  265.     gRTFprocess->handleGroupClass();
  266. }
  267.  
  268.  
  269. extern "C" short rtfGetOneChar()
  270. {
  271. #if 0 //x
  272.             // this is slower than we like -- this is called a lot
  273.     return gRTFprocess->GetOneChar();
  274. #else
  275.     short    c = EOF;
  276.  
  277.     if (gRTFprocess->fDataBuffer) {
  278.         c= *gRTFprocess->fDataBuffer;
  279.         if (gRTFprocess->fDataSize) {    // for counted data
  280.             gRTFprocess->fDataSize--;
  281.             gRTFprocess->fDataBuffer++;
  282.             if (!gRTFprocess->fDataSize) gRTFprocess->fDataBuffer= NULL; //  so EOF next time
  283.             }
  284.         else if (c) gRTFprocess->fDataBuffer++; // for null-term data
  285.         else if (!gRTFprocess->fEndOfData) c= DRichprocess::tokBreakInData;
  286.         else c= EOF;
  287.         }
  288.     else if (gRTFprocess->fDataFile) 
  289.         c = fgetc( gRTFprocess->fDataFile->fFile);
  290.     return (c);
  291. #endif
  292. }
  293.  
  294.  
  295.  
  296. enum {
  297.     kMaxstops = 30
  298.     };
  299.  
  300.  
  301. DRTFprocess::DRTFprocess( DFile* itsFile, DRichView* itsDoc, Nlm_MonitorPtr progress) :
  302.     DRichprocess( itsFile, itsDoc, progress),
  303.     fPict(NULL), fPictKind(0), fInPic(false)
  304. {     
  305.     fPictMax= 0;
  306.     fPictSize= 0;
  307.     fPicNibble= 0;
  308.     fLastNibble= 0;
  309.     fGlobalsInUse= false;
  310.  
  311. #if 1
  312.     // damn, this is a mess    
  313.     fParaFmt.tabstops= (short*) MemNew( kMaxstops * sizeof(short));
  314.     fParaFmt.tabkinds= (char*) MemNew( kMaxstops * sizeof(char));
  315.     fOldParaFmt= fParaFmt;
  316.     fDefParaFmt= fParaFmt;
  317. #endif
  318.     
  319.         // !! DAMN, we can't deal with this kind of global && multiple processors
  320.     if (gRTFprocess) {
  321.         Nlm_Message( MSG_OK, "%s", "RTFprocess globals in use by other processor"); 
  322.         fGlobalsInUse= true;
  323.         return;
  324.         }
  325.     else 
  326.         gRTFprocess= this; 
  327.     
  328.     fOutMap= DRichprocess::gGenCharMap;
  329.  
  330.     RTFInit();
  331.     
  332.     /* install class callbacks */
  333.     RTFSetClassCallback(rtfUnknown, rtfHandleUnknownClass);
  334.     RTFSetClassCallback(rtfText, rtfHandleTextClass);
  335.     RTFSetClassCallback(rtfControl, rtfHandleControlClass);
  336.     RTFSetClassCallback(rtfGroup, rtfHandleGroupClass); 
  337. }
  338.  
  339. DRTFprocess::~DRTFprocess()
  340. {
  341.     Nlm_MemFree(fPict);
  342.     gRTFprocess= NULL;
  343. }
  344.  
  345.  
  346. void DRTFprocess::SetToken()  // temp override
  347. {
  348.         // damn -- some calls to RTFrouteToken bypass our GetToken @!
  349.     fClass= rtfClass; 
  350.     fMajor= rtfMajor;
  351.     fMinor= rtfMinor;
  352.     fParam= rtfParam;
  353. }
  354.  
  355. short DRTFprocess::GetToken()  // temp override
  356. {
  357.     short tok;
  358.     if (fGlobalsInUse) tok= tokEOF;
  359.     else tok= RTFGetToken();
  360.         // DAMN must convert rtftoken vals to new tok vals
  361.     if (tok == rtfEOF) tok= tokEOF;
  362.     
  363.     fClass= tok;
  364.     fMajor= rtfMajor;
  365.     fMinor= rtfMinor;
  366.     fParam= rtfParam;
  367.     return tok;
  368. }
  369.  
  370. void  DRTFprocess::RouteToken() // temp override
  371. {
  372.     RTFRouteToken();
  373. }
  374.  
  375.     
  376. void DRTFprocess::PutPicChar(short c)
  377. {
  378.     if (fPictSize >= fPictMax) {
  379.         fPictMax = fPictSize + 1024;
  380.         if (!fPict) fPict= (char*) Nlm_MemNew(fPictMax+1);
  381.         else fPict= (char*) Nlm_MemMore( fPict, fPictMax+1);
  382.         }
  383.     fPict[fPictSize++]= (char) c;
  384. }
  385.  
  386.  
  387.  
  388. void DRTFprocess::PutStdChar(short stdCode)
  389. {
  390. #if 1
  391.     DRichprocess::PutStdChar(stdCode);
  392. #else
  393.     int och = gOutMap[stdCode];
  394.     if (och == rtfSC_nothing)    {  /* no output sequence in map */
  395.         char    buf[rtfBufSiz];
  396.         sprintf(buf, "{{%s}}", RTFStdCharName (stdCode));
  397.         PutLitStr(buf);
  398.         }
  399.     else {
  400.         PutLitChar(och);
  401.         }
  402. #endif
  403. }
  404.  
  405.  
  406.  
  407.  
  408.  
  409. #define    defaultCharMapFile    "show-gen"  /* should be calling parameter to WriterInit() ? */
  410. #define    defaultSymMapFile        "show-sym"  /* should be calling parameter to WriterInit() ? */
  411. #define defaultRTFfolder         "rtf-maps" 
  412.  
  413.  
  414.  
  415. extern "C" FILE* defaultOpenLibfileProc(char* file, char* mode)
  416. {
  417.     char *pathname, namebuf[512];
  418.     StrNCpy(namebuf, gMapfilePath, 500);
  419.     pathname= Nlm_FileBuildPath(namebuf, NULL, file);
  420.     return Nlm_FileOpen( pathname, mode);
  421. }
  422.  
  423.  
  424.  
  425.  
  426.  
  427.  
  428. void DRTFprocess::RTFWriterInit(char* mapfilepath, char* charMapFile, char* symMapFile)
  429. {    
  430.     /* perform once-only initializations here */
  431.  
  432.     if (mapfilepath)    
  433.         gMapfilePath= StrDup(mapfilepath);
  434.     else {
  435.         char pathname[512];
  436.         char* nameonly;
  437.         long len;
  438.         
  439.         Nlm_ProgramPath( (char*)pathname, 512);
  440.         nameonly= Nlm_FileNameFind( (char*)pathname);
  441.         len= StrLen(pathname) - StrLen(nameonly);
  442.         pathname[len]= 0;
  443.         mapfilepath= Nlm_FileBuildPath(pathname, defaultRTFfolder, NULL);
  444.         gMapfilePath= StrDup(mapfilepath);
  445.         }
  446.  
  447.     /* optionally: RTFSetReadHook( rtfReaderProgressProc); */
  448.     /*  ^^^ if we want to show progress bar or further handle token */
  449.     
  450.     RTFSetOpenLibFileProc( defaultOpenLibfileProc);
  451.  
  452. #if 1
  453.  
  454.     //DRichprocess::gGenCharMap= DRichprocess::ReadOutputMap("gen");
  455.     //DRichprocess::gSymCharMap= DRichprocess::ReadOutputMap("sym");
  456.   //gOutMap= gGenCharMap;
  457.     
  458. #else
  459.     if (charMapFile == NULL) charMapFile= defaultCharMapFile;
  460.     RTFSetCharSetMap( charMapFile, rtfCSGeneral);
  461.     if (RTFReadOutputMap (charMapFile, gGenCharMap, 1) == 0)
  462.         RTFPanic ("Cannot read output map %s", charMapFile);
  463.   gOutMap= gGenCharMap;
  464.   
  465.     if (symMapFile == NULL) symMapFile= defaultSymMapFile;
  466.     RTFSetCharSetMap( symMapFile, rtfCSSymbol);
  467.     if (RTFReadOutputMap (symMapFile, gSymCharMap, 1) == 0)
  468.         RTFPanic ("Cannot read output map %s", symMapFile);
  469. #endif        
  470.         
  471. #if 0
  472.     /* one time generate charsets in .h format */
  473.     RTFReadCharSetMap ("mac-gen", rtfCSGeneral);
  474.     RTFReadCharSetMap ("mac-sym", rtfCSSymbol);        // superset of ansi-sym !
  475.     RTFReadCharSetMap ("mwin-gen", rtfCSGeneral); // superset of ansi-gen 
  476.     RTFReadCharSetMap ("pc-gen", rtfCSGeneral);
  477.     RTFReadCharSetMap ("pc-sym", rtfCSSymbol);        // == ansi-sym
  478.     RTFReadCharSetMap ("pca-gen", rtfCSGeneral);
  479.     RTFReadCharSetMap ("pca-sym", rtfCSSymbol);        // == ansi-sym
  480.     RTFReadCharSetMap ("ansi-gen", rtfCSGeneral);
  481.     RTFReadCharSetMap ("ansi-sym", rtfCSSymbol);
  482.     //RTFReadCharSetMap ("show-gen", rtfCSGeneral);
  483.     //RTFReadCharSetMap ("show-sym", rtfCSSymbol);
  484. #endif
  485.  
  486. }
  487.  
  488.  
  489.  
  490. void DRTFprocess::RTFWriterEnd()
  491. {
  492.     Nlm_MemFree( gMapfilePath);
  493. }
  494.  
  495.  
  496.  
  497.  
  498.  
  499.  
  500. void DRTFprocess::handleTextClass()
  501. {
  502.     if (fInPic) {
  503.             // this is encoded pic data, need opts for binary pic data !
  504.         if (fPicNibble & 1) {
  505.             short abyte = RTFCharToHex(fLastNibble) * 16 + RTFCharToHex(fMajor);
  506.             PutPicChar( abyte);
  507.             }
  508.         else  
  509.             fLastNibble= fMajor;
  510.         fPicNibble++;
  511.         }
  512.         
  513.     else {
  514.         if (IsNewStyle()) StoreStyle(fOldStyleRec.style, FALSE); 
  515.         
  516.         if (fMinor != rtfSC_nothing)
  517.             PutStdChar(fMinor); 
  518.         else {
  519.             char    buf[rtfBufSiz];
  520.             if (fMajor < 128)    /* in ASCII range */
  521.                 sprintf(buf, "[[%c]]", fMajor);
  522.             else
  523.                 sprintf(buf, "[[\\'%02x]]", fMajor);
  524.             PutLitStr(buf);
  525.             }
  526.         }
  527. }
  528.  
  529.  
  530. void DRTFprocess::handleGroupClass()
  531. {
  532.  
  533.     switch (fMajor) {
  534.     
  535.     case rtfBeginGroup:
  536.         /* push gStyleRec .. */
  537.         if (fStyleStackSize<kMaxStyleStack) fStyleStack[fStyleStackSize++]= fStyleRec;
  538.         break;
  539.         
  540.     case rtfEndGroup:
  541.     
  542.         if (fInPic) {
  543.             /* end of pic data here... */
  544.  
  545.             fPict[fPictSize]= 0;
  546.             fStyleRec.style.font= fFont; /* !?!? */
  547.             fStyleRec.style.ispict= TRUE;
  548. #if 1
  549.             fStyleRec.style.fPict= 
  550.                     new DPictStyle( fPictKind, fPict, fPictSize, false); 
  551. #else
  552.             fStyleRec.style.picdata= (char*) MemDup(fPict, fPictSize); 
  553.             fStyleRec.style.picsize= fPictSize;
  554.             fStyleRec.style.pickind= fPictKind;
  555. #endif
  556.  
  557.             PutLitChar(' '); // (chPictTag); /* put a space for some real text ? */
  558.             StoreStyle(fStyleRec.style, TRUE);
  559.  
  560.             fPictSize= 0;
  561.             fPicNibble= 0;
  562.             fLastNibble= 0;
  563. #if 1
  564.             fStyleRec.style.fPict= NULL;
  565. #else
  566.             fStyleRec.style.picdata= 0;
  567.             fStyleRec.style.picsize= 0;
  568.             fStyleRec.style.pickind= 0;
  569. #endif
  570.             fStyleRec.style.ispict= FALSE;
  571.             fStyleRec.style.pixwidth= 0; 
  572.             fStyleRec.style.pixheight= 0; 
  573.             fOldStyleRec= fStyleRec;
  574.             fOldStyleRec.fontname= NULL; /* ?? force new style ? */
  575.             fInPic= FALSE;
  576.             StoreStyle(fStyleRec.style, TRUE);
  577.             PutLitChar(' '); /* put a space for some real text ? */
  578.             }
  579.             
  580.         if (fStyleStackSize>0) fStyleRec= fStyleStack[--fStyleStackSize];
  581.             
  582.         if (StrNICmp (fStyleRec.fontname, "Symbol", 6) == 0) {
  583.             RTFSetCharSet(rtfCSSymbol);
  584.             if (fOutMap != gSymCharMap) fOutMap= gSymCharMap;
  585.             }
  586.         else {
  587.             RTFSetCharSet(rtfCSGeneral);
  588.             if (fOutMap != gGenCharMap) fOutMap= gGenCharMap;
  589.             }
  590.         NewStyle();
  591.         break;    
  592.         }
  593.  
  594. }
  595.  
  596.  
  597. void DRTFprocess::handleControlClass()
  598. {
  599.     switch (fMajor) {
  600.  
  601.     case rtfVersion:
  602.         break;
  603.     case rtfDefFont:
  604.         /*
  605.          * fParam contains the default font number.  Beware
  606.          * that there is no guarantee that this font will actually
  607.          * be listed in the font table!
  608.          */
  609.         break;
  610.     case rtfCharSet:
  611.         /* handled by reader */
  612.         break;
  613.     case rtfDestination:
  614.         Destination();
  615.         break;
  616.     case rtfFontFamily:
  617.         /* only occurs within font table - can ignore */
  618.         break;
  619.     case rtfColorName:
  620.         /* only occurs within color table - can ignore */
  621.         break;
  622.     case rtfSpecialChar:
  623.         SpecialChar();
  624.         break;
  625.     case rtfStyleAttr:
  626.         /* only occurs within stylesheet - can ignore */
  627.         break;
  628.     case rtfDocAttr:
  629.         DocAttr();
  630.         break;
  631.     case rtfSectAttr:
  632.         SectAttr();
  633.         break;
  634.     case rtfTblAttr:
  635.         TblAttr();
  636.         break;
  637.     case rtfParAttr:
  638.         ParAttr();
  639.         break;
  640.     case rtfCharAttr:
  641.         CharAttr();
  642.         break;
  643.     case rtfPictAttr:
  644.         PictAttr();
  645.         break;
  646.     case rtfBookmarkAttr:
  647.         BookmarkAttr();
  648.         break;
  649.     case rtfNeXTGrAttr:
  650.         NeXTGrAttr();
  651.         break;
  652.     case rtfFieldAttr:
  653.         FieldAttr();
  654.         break;
  655.     case rtfTOCAttr:
  656.         TOCAttr();
  657.         break;
  658.     case rtfPosAttr:
  659.         PosAttr();
  660.         break;
  661.     case rtfObjAttr:
  662.         ObjAttr();
  663.         break;
  664.     case rtfFNoteAttr:
  665.         FNoteAttr();
  666.         break;
  667.     case rtfKeyCodeAttr:
  668.         KeyCodeAttr();
  669.         break;
  670.     case rtfACharAttr:
  671.         ACharAttr();
  672.         break;
  673.     case rtfFontAttr:
  674.         FontAttr();
  675.         break;
  676.     case rtfFileAttr:
  677.         FileAttr();
  678.         break;
  679.     case rtfFileSource:
  680.         FileSource();
  681.         break;
  682.     case rtfDrawAttr:
  683.         DrawAttr();
  684.         break;
  685.     case rtfIndexAttr:
  686.         IndexAttr();
  687.         break;
  688.     }
  689.  
  690. }
  691.  
  692.  
  693. /*
  694.  * Control class major number handlers.  Each one switches on
  695.  * the minor numbers that occur within the major number.
  696.  */
  697. /*
  698.  * This function notices destinations that should be ignored
  699.  * and skips to their ends.  This keeps, for instance, picture
  700.  * data from being considered as plain text.
  701.  */
  702.  
  703.  
  704. void DRTFprocess::Destination()
  705. {
  706.     switch (fMinor)
  707.     {
  708.     
  709.     case rtfFontTbl:
  710.         /* will never occur because of default destination reader */
  711.         break;
  712.     case rtfFontAltName:
  713.         break;
  714.     case rtfEmbeddedFont:
  715.         break;
  716.     case rtfFontFile:
  717.         break;
  718.     case rtfFileTbl:
  719.         break;
  720.     case rtfFileInfo:
  721.         break;
  722.     case rtfColorTbl:
  723.         /* will never occur because of default destination reader */
  724.         break;
  725.     case rtfStyleSheet:
  726.         /* will never occur because of default destination reader */
  727.         break;
  728.     case rtfKeyCode:
  729.         /*
  730.          * Currently will never occur because the stylesheet
  731.          * reader eats the keycode group.
  732.          */
  733.         break;
  734.     case rtfRevisionTbl:
  735.         break;
  736.     case rtfInfo:
  737.         RTFSkipGroup();
  738.         break;
  739.     case rtfITitle:
  740.         RTFSkipGroup();
  741.         break;
  742.     case rtfISubject:
  743.         RTFSkipGroup();
  744.         break;
  745.     case rtfIAuthor:
  746.         break;
  747.         RTFSkipGroup();
  748.     case rtfIOperator:
  749.         RTFSkipGroup();
  750.         break;
  751.     case rtfIKeywords:
  752.         RTFSkipGroup();
  753.         break;
  754.     case rtfIComment:
  755.         RTFSkipGroup();
  756.         break;
  757.     case rtfIVersion:
  758.         RTFSkipGroup();
  759.         break;
  760.     case rtfIDoccomm:
  761.         RTFSkipGroup();
  762.         break;
  763.     case rtfIVerscomm:
  764.         break;
  765.     case rtfNextFile:
  766.         RTFSkipGroup();    /* dgg */
  767.         break;
  768.     case rtfTemplate:
  769.         RTFSkipGroup();    /* dgg */
  770.         break;
  771.     case rtfFNSep:
  772.         break;
  773.     case rtfFNContSep:
  774.         RTFSkipGroup();
  775.         break;
  776.     case rtfFNContNotice:
  777.         RTFSkipGroup();
  778.         break;
  779.     case rtfENSep:
  780.         break;
  781.     case rtfENContSep:
  782.         break;
  783.     case rtfENContNotice:
  784.         break;
  785.     case rtfPageNumLevel:
  786.         break;
  787.     case rtfParNumLevelStyle:
  788.         break;
  789.         
  790.     case rtfHeader:
  791.         break;
  792.     case rtfFooter:
  793.         break;
  794.     case rtfHeaderLeft:
  795.         break;
  796.     case rtfHeaderRight:
  797.         break;
  798.     case rtfHeaderFirst:
  799.         break;
  800.     case rtfFooterLeft:
  801.         break;
  802.     case rtfFooterRight:
  803.         break;
  804.     case rtfFooterFirst:
  805.         break;
  806.         
  807.     case rtfParNumText:
  808.         break;
  809.     case rtfParNumbering:
  810.         break;
  811.     case rtfParNumTextAfter:
  812.         break;
  813.     case rtfParNumTextBefore:
  814.         break;
  815.     case rtfBookmarkStart:
  816.         break;
  817.     case rtfBookmarkEnd:
  818.         break;
  819.         
  820.     case rtfPict:
  821.         /* at first, parse group and pull out pict size: \pict\macpict\picw34\pich21\picscaled 
  822.         /* RTFSkipGroup();   /* !! fix this later to process pict */
  823.         /* NewParagraph();  ?? */
  824.         break;
  825.         
  826.     case rtfObject:
  827.         break;
  828.     case rtfObjClass:
  829.         break;
  830.     case rtfObjName:
  831.         break;
  832.     case rtfObjTime:
  833.         break;
  834.     case rtfObjData:
  835.         break;
  836.     case rtfObjAlias:
  837.         break;
  838.     case rtfObjSection:
  839.         break;
  840.     case rtfObjResult:
  841.         break;
  842.     case rtfObjItem:
  843.         break;
  844.     case rtfObjTopic:
  845.         break;
  846.     case rtfDrawObject:
  847.         break;
  848.     case rtfFootnote:
  849.         break;
  850.     case rtfAnnotRefStart:
  851.         break;
  852.     case rtfAnnotRefEnd:
  853.         break;
  854.     case rtfAnnotID:
  855.         break;
  856.     case rtfAnnotAuthor:
  857.         break;
  858.     case rtfAnnotation:
  859.         break;
  860.     case rtfAnnotRef:
  861.         break;
  862.     case rtfAnnotTime:
  863.         break;
  864.     case rtfAnnotIcon:
  865.         break;
  866.         
  867.     case rtfField:
  868.         break;
  869.     case rtfFieldInst:
  870.         RTFSkipGroup(); /* dgg, 27may94 */
  871.         break;
  872.     case rtfFieldResult:
  873.         /* this text should be displayed... */
  874.         break;
  875.     case rtfDataField:
  876.         RTFSkipGroup(); /* ?? binary data?? dgg, 27may94 */
  877.         break;
  878.         
  879.     case rtfIndex:
  880.         break;
  881.     case rtfIndexText:
  882.         break;
  883.     case rtfIndexRange:
  884.         RTFSkipGroup();
  885.         break;
  886.     case rtfTOC:
  887.         break;
  888.     case rtfNeXTGraphic:
  889.         break;
  890.     }
  891. }
  892.  
  893.  
  894. void DRTFprocess::SpecialChar()
  895. {
  896.     switch (fMinor)
  897.     {
  898.     case rtfIIntVersion:
  899.         break;
  900.     case rtfICreateTime:
  901.         break;
  902.     case rtfIRevisionTime:
  903.         break;
  904.     case rtfIPrintTime:
  905.         break;
  906.     case rtfIBackupTime:
  907.         break;
  908.     case rtfIEditTime:
  909.         break;
  910.     case rtfIYear:
  911.         break;
  912.     case rtfIMonth:
  913.         break;
  914.     case rtfIDay:
  915.         break;
  916.     case rtfIHour:
  917.         break;
  918.     case rtfIMinute:
  919.         break;
  920.     case rtfISecond:
  921.         break;
  922.     case rtfINPages:
  923.         break;
  924.     case rtfINWords:
  925.         break;
  926.     case rtfINChars:
  927.         break;
  928.     case rtfIIntID:
  929.         break;
  930.     case rtfCurHeadDate:
  931.         break;
  932.     case rtfCurHeadDateLong:
  933.         break;
  934.     case rtfCurHeadDateAbbrev:
  935.         break;
  936.     case rtfCurHeadTime:
  937.         break;
  938.     case rtfCurHeadPage:
  939.         break;
  940.     case rtfSectNum:
  941.         break;
  942.     case rtfCurFNote:
  943.         break;
  944.     case rtfCurAnnotRef:
  945.         break;
  946.     case rtfFNoteSep:
  947.         break;
  948.     case rtfFNoteCont:
  949.         break;
  950.     case rtfCell:
  951.         PutStdCharWithStyle (rtfSC_space);    /* make sure cells are separated */
  952.         break;
  953.         
  954.     case rtfRow:
  955.         PutLitCharWithStyle ('\n');
  956.         break;
  957.     case rtfPar:
  958.         PutLitCharWithStyle ('\n');
  959.         NewParagraph();
  960.         break;
  961.     case rtfSect:
  962.         PutLitCharWithStyle ('\n');
  963.         NewParagraph(); /* ?? */
  964.         break;
  965.     case rtfPage:
  966.         PutLitCharWithStyle ('\n');
  967.         fParaFmt.newPage= TRUE; /* ?? ??*/
  968.         NewParagraph();
  969.         fParaFmt.newPage= FALSE; /* ?? ?? */
  970.         break;
  971.     case rtfColumn:
  972.         break;
  973.     case rtfLine:
  974.         PutLitCharWithStyle ('\n');
  975.         break;
  976.         
  977.     case rtfSoftPage:
  978.         break;
  979.     case rtfSoftColumn:
  980.         break;
  981.     case rtfSoftLine:
  982.         break;
  983.     case rtfSoftLineHt:
  984.         break;
  985.         
  986.     case rtfTab:
  987.         PutLitCharWithStyle ('\t'); 
  988.         break;
  989.         
  990.     case rtfEmDash:
  991.         PutStdCharWithStyle (rtfSC_emdash);
  992.         break;
  993.     case rtfEnDash:
  994.         PutStdCharWithStyle (rtfSC_endash);
  995.         break;
  996.     case rtfEmSpace:
  997.         break;
  998.     case rtfEnSpace:
  999.         break;
  1000.     case rtfBullet:
  1001.         PutStdCharWithStyle (rtfSC_bullet);
  1002.         break;
  1003.     case rtfLQuote:
  1004.         PutStdCharWithStyle (rtfSC_quoteleft);
  1005.         break;
  1006.     case rtfRQuote:
  1007.         PutStdCharWithStyle (rtfSC_quoteright);
  1008.         break;
  1009.     case rtfLDblQuote:
  1010.         PutStdCharWithStyle (rtfSC_quotedblleft);
  1011.         break;
  1012.     case rtfRDblQuote:
  1013.         PutStdCharWithStyle (rtfSC_quotedblright);
  1014.         break;
  1015.     case rtfFormula:
  1016.         break;
  1017.     case rtfNoBrkSpace:
  1018.         PutStdCharWithStyle (rtfSC_nobrkspace);
  1019.         break;
  1020.     case rtfNoReqHyphen:
  1021.         break;
  1022.     case rtfNoBrkHyphen:
  1023.         PutStdCharWithStyle (rtfSC_nobrkhyphen);
  1024.         break;
  1025.     case rtfOptDest:
  1026.         break;
  1027.     case rtfLTRMark:
  1028.         break;
  1029.     case rtfRTLMark:
  1030.         break;
  1031.     case rtfNoWidthJoiner:
  1032.         break;
  1033.     case rtfNoWidthNonJoiner:
  1034.         break;
  1035.     case rtfCurHeadPict:
  1036.         break;
  1037.     }
  1038. }
  1039.  
  1040.  
  1041. void DRTFprocess::DocAttr()
  1042. {
  1043.     switch (fMinor)
  1044.     {
  1045.     case rtfDefTab:
  1046.         fParaFmt.deftabstop = (int) fParam / 20;
  1047.         break;
  1048.         
  1049.     case rtfHyphHotZone:
  1050.         break;
  1051.     case rtfHyphConsecLines:
  1052.         break;
  1053.     case rtfHyphCaps:
  1054.         break;
  1055.     case rtfHyphAuto:
  1056.         break;
  1057.     case rtfLineStart:
  1058.         break;
  1059.     case rtfFracWidth:
  1060.         break;
  1061.     case rtfMakeBackup:
  1062.         break;
  1063.     case rtfRTFDefault:
  1064.         break;
  1065.     case rtfPSOverlay:
  1066.         break;
  1067.     case rtfDocTemplate:
  1068.         break;
  1069.     case rtfDefLanguage:
  1070.         break;
  1071.     case rtfFENoteType:
  1072.         break;
  1073.     case rtfFNoteEndSect:
  1074.         break;
  1075.     case rtfFNoteEndDoc:
  1076.         break;
  1077.     case rtfFNoteText:
  1078.         break;
  1079.     case rtfFNoteBottom:
  1080.         break;
  1081.     case rtfENoteEndSect:
  1082.         break;
  1083.     case rtfENoteEndDoc:
  1084.         break;
  1085.     case rtfENoteText:
  1086.         break;
  1087.     case rtfENoteBottom:
  1088.         break;
  1089.     case rtfFNoteStart:
  1090.         break;
  1091.     case rtfENoteStart:
  1092.         break;
  1093.     case rtfFNoteRestartPage:
  1094.         break;
  1095.     case rtfFNoteRestart:
  1096.         break;
  1097.     case rtfFNoteRestartCont:
  1098.         break;
  1099.     case rtfENoteRestart:
  1100.         break;
  1101.     case rtfENoteRestartCont:
  1102.         break;
  1103.     case rtfFNoteNumArabic:
  1104.         break;
  1105.     case rtfFNoteNumLLetter:
  1106.         break;
  1107.     case rtfFNoteNumULetter:
  1108.         break;
  1109.     case rtfFNoteNumLRoman:
  1110.         break;
  1111.     case rtfFNoteNumURoman:
  1112.         break;
  1113.     case rtfFNoteNumChicago:
  1114.         break;
  1115.     case rtfENoteNumArabic:
  1116.         break;
  1117.     case rtfENoteNumLLetter:
  1118.         break;
  1119.     case rtfENoteNumULetter:
  1120.         break;
  1121.     case rtfENoteNumLRoman:
  1122.         break;
  1123.     case rtfENoteNumURoman:
  1124.         break;
  1125.     case rtfENoteNumChicago:
  1126.         break;
  1127.         
  1128.     case rtfPaperWidth:
  1129.         break;
  1130.     case rtfPaperHeight:
  1131.         break;
  1132.     case rtfPaperSize:
  1133.         break;
  1134.     case rtfLeftMargin:
  1135.         break;
  1136.     case rtfRightMargin:
  1137.         break;
  1138.     case rtfTopMargin:
  1139.         break;
  1140.     case rtfBottomMargin:
  1141.         break;
  1142.     case rtfFacingPage:
  1143.         break;
  1144.     case rtfGutterWid:
  1145.         break;
  1146.     case rtfMirrorMargin:
  1147.         break;
  1148.     case rtfLandscape:
  1149.         break;
  1150.     case rtfPageStart:
  1151.         break;
  1152.     case rtfWidowCtrl:
  1153.         break;
  1154.     case rtfLinkStyles:
  1155.         break;
  1156.     case rtfNoAutoTabIndent:
  1157.         break;
  1158.     case rtfWrapSpaces:
  1159.         break;
  1160.     case rtfPrintColorsBlack:
  1161.         break;
  1162.     case rtfNoExtraSpaceRL:
  1163.         break;
  1164.     case rtfNoColumnBalance:
  1165.         break;
  1166.     case rtfCvtMailMergeQuote:
  1167.         break;
  1168.     case rtfSuppressTopSpace:
  1169.         break;
  1170.     case rtfSuppressPreParSpace:
  1171.         break;
  1172.     case rtfCombineTblBorders:
  1173.         break;
  1174.     case rtfTranspMetafiles:
  1175.         break;
  1176.     case rtfSwapBorders:
  1177.         break;
  1178.     case rtfShowHardBreaks:
  1179.         break;
  1180.     case rtfFormProtected:
  1181.         break;
  1182.     case rtfAllProtected:
  1183.         break;
  1184.     case rtfFormShading:
  1185.         break;
  1186.     case rtfFormDisplay:
  1187.         break;
  1188.     case rtfPrintData:
  1189.         break;
  1190.     case rtfRevProtected:
  1191.         break;
  1192.     case rtfRevisions:
  1193.         break;
  1194.     case rtfRevDisplay:
  1195.         break;
  1196.     case rtfRevBar:
  1197.         break;
  1198.     case rtfAnnotProtected:
  1199.         break;
  1200.     case rtfRTLDoc:
  1201.         break;
  1202.     case rtfLTRDoc:
  1203.         break;
  1204.     }
  1205. }
  1206.  
  1207.  
  1208. void DRTFprocess::SectAttr()
  1209. {
  1210.     switch (fMinor)
  1211.     {
  1212.     case rtfSectDef:
  1213.         break;
  1214.     case rtfENoteHere:
  1215.         break;
  1216.     case rtfPrtBinFirst:
  1217.         break;
  1218.     case rtfPrtBin:
  1219.         break;
  1220.     case rtfSectStyleNum:
  1221.         break;
  1222.     case rtfNoBreak:
  1223.         break;
  1224.     case rtfColBreak:
  1225.         break;
  1226.     case rtfPageBreak:
  1227.         break;
  1228.     case rtfEvenBreak:
  1229.         break;
  1230.     case rtfOddBreak:
  1231.         break;
  1232.     case rtfColumns:
  1233.         break;
  1234.     case rtfColumnSpace:
  1235.         break;
  1236.     case rtfColumnNumber:
  1237.         break;
  1238.     case rtfColumnSpRight:
  1239.         break;
  1240.     case rtfColumnWidth:
  1241.         break;
  1242.     case rtfColumnLine:
  1243.         break;
  1244.     case rtfLineModulus:
  1245.         break;
  1246.     case rtfLineDist:
  1247.         break;
  1248.     case rtfLineStarts:
  1249.         break;
  1250.     case rtfLineRestart:
  1251.         break;
  1252.     case rtfLineRestartPg:
  1253.         break;
  1254.     case rtfLineCont:
  1255.         break;
  1256.     case rtfSectPageWid:
  1257.         break;
  1258.     case rtfSectPageHt:
  1259.         break;
  1260.     case rtfSectMarginLeft:
  1261.         break;
  1262.     case rtfSectMarginRight:
  1263.         break;
  1264.     case rtfSectMarginTop:
  1265.         break;
  1266.     case rtfSectMarginBottom:
  1267.         break;
  1268.     case rtfSectMarginGutter:
  1269.         break;
  1270.     case rtfSectLandscape:
  1271.         break;
  1272.     case rtfTitleSpecial:
  1273.         break;
  1274.     case rtfHeaderY:
  1275.         break;
  1276.     case rtfFooterY:
  1277.         break;
  1278.     case rtfPageStarts:
  1279.         break;
  1280.     case rtfPageCont:
  1281.         break;
  1282.     case rtfPageRestart:
  1283.         break;
  1284.     case rtfPageNumRight:
  1285.         break;
  1286.     case rtfPageNumTop:
  1287.         break;
  1288.     case rtfPageDecimal:
  1289.         break;
  1290.     case rtfPageURoman:
  1291.         break;
  1292.     case rtfPageLRoman:
  1293.         break;
  1294.     case rtfPageULetter:
  1295.         break;
  1296.     case rtfPageLLetter:
  1297.         break;
  1298.     case rtfPageNumHyphSep:
  1299.         break;
  1300.     case rtfPageNumSpaceSep:
  1301.         break;
  1302.     case rtfPageNumColonSep:
  1303.         break;
  1304.     case rtfPageNumEmdashSep:
  1305.         break;
  1306.     case rtfPageNumEndashSep:
  1307.         break;
  1308.     case rtfTopVAlign:
  1309.         break;
  1310.     case rtfBottomVAlign:
  1311.         break;
  1312.     case rtfCenterVAlign:
  1313.         break;
  1314.     case rtfJustVAlign:
  1315.         break;
  1316.     case rtfRTLSect:
  1317.         break;
  1318.     case rtfLTRSect:
  1319.         break;
  1320.     }
  1321. }
  1322.  
  1323.  
  1324. void DRTFprocess::TblAttr()
  1325. {
  1326.     switch (fMinor)
  1327.     {
  1328.     case rtfRowDef:
  1329.         break;
  1330.     case rtfRowGapH:
  1331.         break;
  1332.     case rtfCellPos:
  1333.         break;
  1334.     case rtfMergeRngFirst:
  1335.         break;
  1336.     case rtfMergePrevious:
  1337.         break;
  1338.     case rtfRowLeft:
  1339.         break;
  1340.     case rtfRowRight:
  1341.         break;
  1342.     case rtfRowCenter:
  1343.         break;
  1344.     case rtfRowLeftEdge:
  1345.         break;
  1346.     case rtfRowHt:
  1347.         break;
  1348.     case rtfRowHeader:
  1349.         break;
  1350.     case rtfRowKeep:
  1351.         break;
  1352.     case rtfRTLRow:
  1353.         break;
  1354.     case rtfLTRRow:
  1355.         break;
  1356.     case rtfRowBordTop:
  1357.         break;
  1358.     case rtfRowBordLeft:
  1359.         break;
  1360.     case rtfRowBordBottom:
  1361.         break;
  1362.     case rtfRowBordRight:
  1363.         break;
  1364.     case rtfRowBordHoriz:
  1365.         break;
  1366.     case rtfRowBordVert:
  1367.         break;
  1368.     case rtfCellBordBottom:
  1369.         break;
  1370.     case rtfCellBordTop:
  1371.         break;
  1372.     case rtfCellBordLeft:
  1373.         break;
  1374.     case rtfCellBordRight:
  1375.         break;
  1376.     case rtfCellShading:
  1377.         break;
  1378.     case rtfCellBgPatH:
  1379.         break;
  1380.     case rtfCellBgPatV:
  1381.         break;
  1382.     case rtfCellFwdDiagBgPat:
  1383.         break;
  1384.     case rtfCellBwdDiagBgPat:
  1385.         break;
  1386.     case rtfCellHatchBgPat:
  1387.         break;
  1388.     case rtfCellDiagHatchBgPat:
  1389.         break;
  1390.     case rtfCellDarkBgPatH:
  1391.         break;
  1392.     case rtfCellDarkBgPatV:
  1393.         break;
  1394.     case rtfCellFwdDarkBgPat:
  1395.         break;
  1396.     case rtfCellBwdDarkBgPat:
  1397.         break;
  1398.     case rtfCellDarkHatchBgPat:
  1399.         break;
  1400.     case rtfCellDarkDiagHatchBgPat:
  1401.         break;
  1402.     case rtfCellBgPatLineColor:
  1403.         break;
  1404.     case rtfCellBgPatColor:
  1405.         break;
  1406.     }
  1407. }
  1408.  
  1409.  
  1410. void DRTFprocess::ParAttr()
  1411. {
  1412.     switch (fMinor)
  1413.     {
  1414.     case rtfParDef:
  1415.         DefaultParag();
  1416.         break;
  1417.     case rtfStyleNum:
  1418.         RTFExpandStyle (fParam);
  1419.         break;
  1420.         
  1421.     case rtfHyphenate:
  1422.         break;
  1423.     case rtfInTable:
  1424.         break;
  1425.     case rtfKeep:
  1426.         break;
  1427.     case rtfNoWidowControl:
  1428.         break;
  1429.     case rtfKeepNext:
  1430.         break;
  1431.     case rtfOutlineLevel:
  1432.         break;
  1433.     case rtfNoLineNum:
  1434.         break;
  1435.     case rtfPBBefore:
  1436.         break;
  1437.     case rtfSideBySide:
  1438.         break;
  1439.     case rtfQuadLeft:
  1440.         fParaFmt.just= 'l';
  1441.         break;
  1442.     case rtfQuadRight:
  1443.         fParaFmt.just= 'r';
  1444.         break;
  1445.     case rtfQuadJust:
  1446.         fParaFmt.just= 'l';
  1447.         break;
  1448.     case rtfQuadCenter:
  1449.         fParaFmt.just= 'c';
  1450.         break;
  1451.  
  1452.     case rtfFirstIndent:
  1453.         fParaFmt.firstInset= fParam / 20;  
  1454.         break;
  1455.     case rtfLeftIndent:
  1456.         fParaFmt.leftInset= fParam / 20;  
  1457.         break;
  1458.     case rtfRightIndent:
  1459.         fParaFmt.rightInset= fParam / 20; 
  1460.         break;
  1461.  
  1462. #if 1        
  1463.     case rtfSpaceBefore:
  1464.         fParaFmt.spaceBefore= fParam / 20; 
  1465.         break;
  1466.     case rtfSpaceAfter:
  1467.         fParaFmt.spaceAfter= fParam / 20; 
  1468.         break;
  1469. #endif
  1470.     case rtfSpaceBetween:
  1471.         fParaFmt.spaceBetween= fParam / 20; 
  1472.         break;
  1473.     case rtfSpaceMultiply:
  1474.         fParaFmt.spaceMultiply= (fParam > 0); 
  1475.         break;
  1476.     case rtfSubDocument:
  1477.         break;
  1478.     case rtfRTLPar:
  1479.         break;
  1480.     case rtfLTRPar:
  1481.         break;
  1482.         
  1483.     case rtfTabPos:
  1484.         if (fParaFmt.numstops<kMaxstops) {
  1485.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabLeft;   
  1486.         fParaFmt.tabstops[fParaFmt.numstops++]= fParam / 20; 
  1487.         } 
  1488.         break;
  1489.     case rtfTabLeft:
  1490.         if (fParaFmt.numstops<kMaxstops) 
  1491.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabLeft;  
  1492.         break;
  1493.     case rtfTabRight:
  1494.         if (fParaFmt.numstops<kMaxstops) 
  1495.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabRight;  
  1496.         break;
  1497.     case rtfTabCenter:
  1498.         if (fParaFmt.numstops<kMaxstops) 
  1499.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabCenter;  
  1500.         break;
  1501.     case rtfTabDecimal:
  1502.         if (fParaFmt.numstops<kMaxstops) 
  1503.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabDecimal;  
  1504.         break;
  1505.     case rtfTabBar:
  1506.         if (fParaFmt.numstops<kMaxstops) {
  1507.         fParaFmt.tabkinds[fParaFmt.numstops]= DParagraph::kTabBar;  
  1508.         fParaFmt.tabstops[fParaFmt.numstops++]= fParam / 20;  
  1509.         }
  1510.         break;
  1511.         
  1512.     case rtfLeaderDot:
  1513.         fParaFmt.tablead= '.';
  1514.         break;
  1515.     case rtfLeaderHyphen:
  1516.         fParaFmt.tablead= '-';
  1517.         break;
  1518.     case rtfLeaderUnder:
  1519.         fParaFmt.tablead= '_';
  1520.         break;
  1521.     case rtfLeaderThick:
  1522.         fParaFmt.tablead= '=';
  1523.         break;
  1524.     case rtfLeaderEqual:
  1525.         fParaFmt.tablead= '=';
  1526.         break;
  1527.         
  1528.     case rtfParLevel:
  1529.         break;
  1530.     case rtfParBullet:
  1531.         break;
  1532.     case rtfParSimple:
  1533.         break;
  1534.     case rtfParNumCont:
  1535.         break;
  1536.     case rtfParNumOnce:
  1537.         break;
  1538.     case rtfParNumAcross:
  1539.         break;
  1540.     case rtfParHangIndent:
  1541.         break;
  1542.     case rtfParNumRestart:
  1543.         break;
  1544.     case rtfParNumCardinal:
  1545.         break;
  1546.     case rtfParNumDecimal:
  1547.         break;
  1548.     case rtfParNumULetter:
  1549.         break;
  1550.     case rtfParNumURoman:
  1551.         break;
  1552.     case rtfParNumLLetter:
  1553.         break;
  1554.     case rtfParNumLRoman:
  1555.         break;
  1556.     case rtfParNumOrdinal:
  1557.         break;
  1558.     case rtfParNumOrdinalText:
  1559.         break;
  1560.     case rtfParNumBold:
  1561.         break;
  1562.     case rtfParNumItalic:
  1563.         break;
  1564.     case rtfParNumAllCaps:
  1565.         break;
  1566.     case rtfParNumSmallCaps:
  1567.         break;
  1568.     case rtfParNumUnder:
  1569.         break;
  1570.     case rtfParNumDotUnder:
  1571.         break;
  1572.     case rtfParNumDbUnder:
  1573.         break;
  1574.     case rtfParNumNoUnder:
  1575.         break;
  1576.     case rtfParNumWordUnder:
  1577.         break;
  1578.     case rtfParNumStrikethru:
  1579.         break;
  1580.     case rtfParNumForeColor:
  1581.         break;
  1582.     case rtfParNumFont:
  1583.         break;
  1584.     case rtfParNumFontSize:
  1585.         break;
  1586.     case rtfParNumIndent:
  1587.         break;
  1588.     case rtfParNumSpacing:
  1589.         break;
  1590.     case rtfParNumInclPrev:
  1591.         break;
  1592.     case rtfParNumCenter:
  1593.         break;
  1594.     case rtfParNumLeft:
  1595.         break;
  1596.     case rtfParNumRight:
  1597.         break;
  1598.     case rtfParNumStartAt:
  1599.         break;
  1600.  
  1601.           
  1602.     case rtfBorderTop:
  1603.         fParaFmt.bordertop= TRUE;
  1604.         break;
  1605.     case rtfBorderBottom:
  1606.         fParaFmt.borderbottom= TRUE;
  1607.         /* no help to missing bordr... fParaFmt.leadHeight = 3; /* depends on style... */
  1608.         break;
  1609.     case rtfBorderLeft:
  1610.         fParaFmt.borderleft= TRUE;
  1611.         break;
  1612.     case rtfBorderRight:
  1613.         fParaFmt.borderright= TRUE;
  1614.         break;
  1615.     case rtfBorderBetween:
  1616.         fParaFmt.borderbetween= TRUE;
  1617.         break;
  1618.     case rtfBorderBar:
  1619.         fParaFmt.borderbar= TRUE;
  1620.         break;
  1621.     case rtfBorderBox:
  1622.         fParaFmt.borderbox= TRUE;
  1623.         break;
  1624.         
  1625.     case rtfBorderSingle:
  1626.         fParaFmt.borderstyle = DParagraph::kBorderSingle;
  1627.         break;
  1628.     case rtfBorderThick:
  1629.         fParaFmt.borderstyle = DParagraph::kBorderThick;
  1630.         break;
  1631.     case rtfBorderShadow:
  1632.         fParaFmt.borderstyle = DParagraph::kBorderShadow;
  1633.         break;
  1634.     case rtfBorderDouble:
  1635.         fParaFmt.borderstyle = DParagraph::kBorderDouble;
  1636.         break;
  1637.     case rtfBorderDot:
  1638.         fParaFmt.borderstyle = DParagraph::kBorderDot;
  1639.         break;
  1640.     case rtfBorderDash:
  1641.         fParaFmt.borderstyle = DParagraph::kBorderDash;
  1642.         break;
  1643.     case rtfBorderHair:
  1644.         fParaFmt.borderstyle = DParagraph::kBorderHair;
  1645.         break;
  1646.     case rtfBorderWidth:
  1647.         break;
  1648.     case rtfBorderColor:
  1649.         break;
  1650.     case rtfBorderSpace:
  1651.         break;
  1652.  
  1653.         
  1654.     case rtfShading:
  1655.         break;
  1656.     case rtfBgPatH:
  1657.         break;
  1658.     case rtfBgPatV:
  1659.         break;
  1660.     case rtfFwdDiagBgPat:
  1661.         break;
  1662.     case rtfBwdDiagBgPat:
  1663.         break;
  1664.     case rtfHatchBgPat:
  1665.         break;
  1666.     case rtfDiagHatchBgPat:
  1667.         break;
  1668.     case rtfDarkBgPatH:
  1669.         break;
  1670.     case rtfDarkBgPatV:
  1671.         break;
  1672.     case rtfFwdDarkBgPat:
  1673.         break;
  1674.     case rtfBwdDarkBgPat:
  1675.         break;
  1676.     case rtfDarkHatchBgPat:
  1677.         break;
  1678.     case rtfDarkDiagHatchBgPat:
  1679.         break;
  1680.     case rtfBgPatLineColor:
  1681.         break;
  1682.     case rtfBgPatColor:
  1683.         break;
  1684.     }
  1685. }
  1686.  
  1687.  
  1688. /*
  1689.  * Several of the attributes can be turned off with param value
  1690.  * of zero (e.g., \b vs. \b0), but since the value of fParam
  1691.  * is 0 if no param is given, test the text of the token directly.
  1692.  */
  1693.  
  1694.  
  1695.  
  1696. void DRTFprocess::CharAttr()
  1697. {
  1698.     int    turnOn = (rtfTextBuf[rtfTextLen-1] != '0'); 
  1699.     //NewStyle(); //x
  1700.  
  1701.     switch (fMinor)
  1702.     {
  1703.     case rtfFontNum:
  1704.         {
  1705.         RTFFont * rfnt= RTFGetFont (fParam);
  1706.         if (rfnt) {
  1707.             fStyleRec.fontname= rfnt->rtfFName;
  1708.             switch (rfnt->rtfFFamily) {
  1709.                 case rtfFFRoman : fStyleRec.fontfamily= "Roman"; break;
  1710.                 case rtfFFSwiss : fStyleRec.fontfamily= "Swiss"; break;
  1711.                 case rtfFFModern: fStyleRec.fontfamily= "Modern"; break;
  1712.                 case rtfFFDecor : fStyleRec.fontfamily= "Decorative"; break;
  1713.                 case rtfFFTech     :
  1714.                 case rtfFFNil     : 
  1715.                 default                    : fStyleRec.fontfamily= NULL; break;
  1716.                 }
  1717.             /* !! add default font size ... msword-rtf often leaves out fsize if == 12 pts ! */
  1718.           /* fStyleRec.fontsize= kDefaultFontsize; */
  1719.             }
  1720.         NewStyle();
  1721.             
  1722.         switch (RTFGetCharSet()) {
  1723.             default:         
  1724.             case rtfCSGeneral:
  1725.                 if (fOutMap != gGenCharMap) fOutMap= gGenCharMap;
  1726.                 break;
  1727.             case rtfCSSymbol:
  1728.                 if (fOutMap != gSymCharMap) fOutMap= gSymCharMap;
  1729.                 break;
  1730.             }
  1731.         }
  1732.         break;
  1733.         
  1734.     case rtfFontSize:
  1735.         NewStyle();
  1736.         /* sizes are in half-points, convert to whole points */
  1737.         fStyleRec.fontsize = (int) (fParam / 2);
  1738.         if (fStyleRec.fontsize <= 0) fStyleRec.fontsize = kDefaultFontsize;     /* default size */
  1739.         break;
  1740.  
  1741.     case rtfPlain:
  1742.         NewStyle();
  1743.         fStyleRec.style.bold= FALSE;
  1744.         fStyleRec.style.italic= FALSE;
  1745.         fStyleRec.style.underline= 0;
  1746.         fStyleRec.style.hidden= FALSE;
  1747.         fStyleRec.style.outline= FALSE;
  1748.         fStyleRec.style.strikeout= FALSE;
  1749.         fStyleRec.style.shadow= FALSE;
  1750.         fStyleRec.style.allcaps= FALSE;
  1751.         fStyleRec.style.smallcaps= FALSE;
  1752.         fStyleRec.style.superSub= 0; 
  1753.         fStyleRec.style.color= kBlackColor;  
  1754.         fStyleRec.fontsize= kDefaultFontsize;     /* ?? is this part of plain ? */
  1755.         break;
  1756.         
  1757.     case rtfBold:
  1758.         NewStyle();
  1759.         fStyleRec.style.bold= turnOn;
  1760.         break;
  1761.     case rtfItalic:
  1762.         NewStyle();
  1763.         fStyleRec.style.italic= turnOn;
  1764.         break;
  1765.     case rtfUnderline:
  1766.         NewStyle();
  1767.         if (turnOn) fStyleRec.style.underline = DRichStyle::kUnderline;
  1768.         else fStyleRec.style.underline= 0;
  1769.         break;
  1770.     case rtfWordUnderline:
  1771.         NewStyle();
  1772.         if (turnOn) fStyleRec.style.underline = DRichStyle::kWorduline;
  1773.         else fStyleRec.style.underline= 0;
  1774.         break;
  1775.     case rtfDotUnderline:
  1776.         NewStyle();
  1777.         if (turnOn) fStyleRec.style.underline = DRichStyle::kDotuline;
  1778.         else fStyleRec.style.underline= 0;
  1779.         break;
  1780.     case rtfDbUnderline:
  1781.         NewStyle();
  1782.         if (turnOn) fStyleRec.style.underline = DRichStyle::kDbluline;
  1783.         else fStyleRec.style.underline= 0;
  1784.         break;
  1785.     case rtfNoUnderline:
  1786.         NewStyle();
  1787.         fStyleRec.style.underline= 0;
  1788.         break;
  1789.     case rtfInvisible:
  1790.         NewStyle();
  1791.         fStyleRec.style.hidden= turnOn;
  1792.         break;
  1793.  
  1794.     case rtfOutline:
  1795.         NewStyle();
  1796.         fStyleRec.style.outline= turnOn;
  1797.         break;
  1798.     case rtfAllCaps:
  1799.         NewStyle();
  1800.         fStyleRec.style.allcaps= turnOn;
  1801.         break;
  1802.     case rtfSmallCaps:
  1803.         NewStyle();
  1804.         fStyleRec.style.smallcaps= turnOn;
  1805.         break;
  1806.     case rtfShadow:
  1807.         NewStyle();
  1808.         fStyleRec.style.shadow= turnOn;
  1809.         break;
  1810.     case rtfStrikeThru:
  1811.         NewStyle();
  1812.         fStyleRec.style.strikeout= turnOn;
  1813.         break;
  1814.         
  1815.     case rtfForeColor:
  1816.         {
  1817.         RTFColor *rclr;        
  1818.         NewStyle();
  1819.         rclr= RTFGetColor (fParam);
  1820.         if (rclr) {
  1821.             /* damn, we now have to select color to read it's nlm value... */
  1822.             Nlm_SelectColor( rclr->rtfCRed, rclr->rtfCGreen, rclr->rtfCBlue);
  1823.             fStyleRec.style.color= Nlm_GetColor();
  1824.             }
  1825.         }
  1826.         break;
  1827.     case rtfBackColor:
  1828.         break;
  1829.  
  1830.     case rtfSubScript:
  1831.         NewStyle();
  1832.         fStyleRec.style.superSub=  (int) fParam / 2 ;
  1833.         break;
  1834.     case rtfSubScrShrink:
  1835.         NewStyle();
  1836.         fStyleRec.style.superSub=  (int) (fParam/ 2 );  
  1837.         break;
  1838.     case rtfSuperScript:
  1839.         NewStyle();
  1840.         fStyleRec.style.superSub=  - (int) (fParam/ 2 ); 
  1841.         break;
  1842.     case rtfSuperScrShrink:
  1843.         NewStyle();
  1844.         fStyleRec.style.superSub=  - (int) (fParam/ 2 ); 
  1845.         break;
  1846.     case rtfNoSuperSub:
  1847.         NewStyle();
  1848.         fStyleRec.style.superSub= 0;
  1849.         break;
  1850.  
  1851.         
  1852.     case rtfDeleted:
  1853.         break;
  1854.     case rtfExpand:
  1855.         break;
  1856.     case rtfExpandTwips:
  1857.         break;
  1858.     case rtfKerning:
  1859.         break;
  1860.     case rtfRevised:
  1861.         break;
  1862.     case rtfRevAuthor:
  1863.         break;
  1864.     case rtfRevDTTM:
  1865.         break;
  1866.     case rtfRTLChar:
  1867.         break;
  1868.     case rtfLTRChar:
  1869.         break;
  1870.     case rtfCharStyleNum:
  1871.         break;
  1872.     case rtfCharCharSet:
  1873.         break;
  1874.     case rtfLanguage:
  1875.         SelectLanguage();
  1876.         break;
  1877.     case rtfGray:
  1878.         break;
  1879.     }
  1880. }
  1881.  
  1882.  
  1883. void DRTFprocess::PictAttr()
  1884. {
  1885.  
  1886.     /* all RTF sizes are in Twentieths of a Point (twip), assume 72 points/inch */
  1887.     /* !! assume point == pixel size, bad assumption ?*/
  1888.     fInPic= TRUE;
  1889.     //x NewStyle();
  1890.  
  1891.     switch (fMinor)
  1892.     {
  1893.     case rtfMacQD:
  1894.         fPictKind= DPictStyle::kPictMac;
  1895.         break;
  1896.     case rtfPMMetafile:
  1897.         fPictKind= DPictStyle::kPictPMMeta;
  1898.         break;
  1899.     case rtfWinMetafile:
  1900.         fPictKind= DPictStyle::kPictWinMeta;
  1901.         break;
  1902.     case rtfDevIndBitmap:
  1903.         fPictKind= DPictStyle::kPictDIBits;
  1904.         break;
  1905.     case rtfWinBitmap:
  1906.         fPictKind= DPictStyle::kPictWinBits;
  1907.         break;
  1908.         
  1909.     case rtfPixelBits:
  1910.         break;
  1911.     case rtfBitmapPlanes:
  1912.         break;
  1913.     case rtfBitmapWid:
  1914.         break;
  1915.         
  1916.     case rtfPicWid:
  1917.         fStyleRec.style.pixwidth= fParam; 
  1918.         break;
  1919.     case rtfPicHt:
  1920.         fStyleRec.style.pixheight= fParam;
  1921.         break;
  1922.         
  1923.     case rtfPicGoalWid:
  1924.         break;
  1925.     case rtfPicGoalHt:
  1926.         break;
  1927.     case rtfPicScaleX:
  1928.         break;
  1929.     case rtfPicScaleY:
  1930.         break;
  1931.     case rtfPicScaled:
  1932.         break;
  1933.         
  1934.     case rtfPicCropTop:
  1935.         break;
  1936.     case rtfPicCropBottom:
  1937.         break;
  1938.     case rtfPicCropLeft:
  1939.         break;
  1940.     case rtfPicCropRight:
  1941.         break;
  1942.     case rtfPicMFHasBitmap:
  1943.         break;
  1944.     case rtfPicMFBitsPerPixel:
  1945.         break;
  1946.     case rtfPicBinary:
  1947.         break;
  1948.     }
  1949. }
  1950.  
  1951.  
  1952. void DRTFprocess::BookmarkAttr()
  1953. {
  1954.     switch (fMinor)
  1955.     {
  1956.     case rtfBookmarkFirstCol:
  1957.         break;
  1958.     case rtfBookmarkLastCol:
  1959.         break;
  1960.     }
  1961. }
  1962.  
  1963.  
  1964. void DRTFprocess::NeXTGrAttr()
  1965. {
  1966.     switch (fMinor)
  1967.     {
  1968.     case rtfNeXTGWidth:
  1969.         break;
  1970.     case rtfNeXTGHeight:
  1971.         break;
  1972.     }
  1973. }
  1974.  
  1975.  
  1976. void DRTFprocess::FieldAttr()
  1977. {
  1978.     switch (fMinor)
  1979.     {
  1980.     case rtfFieldDirty:
  1981.         break;
  1982.     case rtfFieldEdited:
  1983.         break;
  1984.     case rtfFieldLocked:
  1985.         break;
  1986.     case rtfFieldPrivate:
  1987.         break;
  1988.     case rtfFieldAlt:
  1989.         break;
  1990.     }
  1991. }
  1992.  
  1993.  
  1994. void DRTFprocess::TOCAttr()
  1995. {
  1996.     switch (fMinor)
  1997.     {
  1998.     case rtfTOCType:
  1999.         break;
  2000.     case rtfTOCLevel:
  2001.         break;
  2002.     }
  2003. }
  2004.  
  2005.  
  2006. void DRTFprocess::PosAttr()
  2007. {
  2008.     switch (fMinor)
  2009.     {
  2010.     case rtfAbsWid:
  2011.         break;
  2012.     case rtfAbsHt:
  2013.         break;
  2014.     case rtfRPosMargH:
  2015.         break;
  2016.     case rtfRPosPageH:
  2017.         break;
  2018.     case rtfRPosColH:
  2019.         break;
  2020.     case rtfPosX:
  2021.         break;
  2022.     case rtfPosNegX:
  2023.         break;
  2024.     case rtfPosXCenter:
  2025.         break;
  2026.     case rtfPosXInside:
  2027.         break;
  2028.     case rtfPosXOutSide:
  2029.         break;
  2030.     case rtfPosXRight:
  2031.         break;
  2032.     case rtfPosXLeft:
  2033.         break;
  2034.     case rtfRPosMargV:
  2035.         break;
  2036.     case rtfRPosPageV:
  2037.         break;
  2038.     case rtfRPosParaV:
  2039.         break;
  2040.     case rtfPosY:
  2041.         break;
  2042.     case rtfPosNegY:
  2043.         break;
  2044.     case rtfPosYInline:
  2045.         break;
  2046.     case rtfPosYTop:
  2047.         break;
  2048.     case rtfPosYCenter:
  2049.         break;
  2050.     case rtfPosYBottom:
  2051.         break;
  2052.     case rtfNoWrap:
  2053.         break;
  2054.     case rtfDistFromTextAll:
  2055.         break;
  2056.     case rtfDistFromTextX:
  2057.         break;
  2058.     case rtfDistFromTextY:
  2059.         break;
  2060.     case rtfTextDistY:
  2061.         break;
  2062.     case rtfDropCapLines:
  2063.         break;
  2064.     case rtfDropCapType:
  2065.         break;
  2066.     }
  2067. }
  2068.  
  2069.  
  2070. void DRTFprocess::ObjAttr()
  2071. {
  2072.     switch (fMinor)
  2073.     {
  2074.     case rtfObjEmb:
  2075.         break;
  2076.     case rtfObjLink:
  2077.         break;
  2078.     case rtfObjAutoLink:
  2079.         break;
  2080.     case rtfObjSubscriber:
  2081.         break;
  2082.     case rtfObjPublisher:
  2083.         break;
  2084.     case rtfObjICEmb:
  2085.         break;
  2086.     case rtfObjLinkSelf:
  2087.         break;
  2088.     case rtfObjLock:
  2089.         break;
  2090.     case rtfObjUpdate:
  2091.         break;
  2092.     case rtfObjHt:
  2093.         break;
  2094.     case rtfObjWid:
  2095.         break;
  2096.     case rtfObjSetSize:
  2097.         break;
  2098.     case rtfObjAlign:
  2099.         break;
  2100.     case rtfObjTransposeY:
  2101.         break;
  2102.     case rtfObjCropTop:
  2103.         break;
  2104.     case rtfObjCropBottom:
  2105.         break;
  2106.     case rtfObjCropLeft:
  2107.         break;
  2108.     case rtfObjCropRight:
  2109.         break;
  2110.     case rtfObjScaleX:
  2111.         break;
  2112.     case rtfObjScaleY:
  2113.         break;
  2114.     case rtfObjResRTF:
  2115.         break;
  2116.     case rtfObjResPict:
  2117.         break;
  2118.     case rtfObjResBitmap:
  2119.         break;
  2120.     case rtfObjResText:
  2121.         break;
  2122.     case rtfObjResMerge:
  2123.         break;
  2124.     case rtfObjBookmarkPubObj:
  2125.         break;
  2126.     case rtfObjPubAutoUpdate:
  2127.         break;
  2128.     }
  2129. }
  2130.  
  2131.  
  2132. void DRTFprocess::FNoteAttr()
  2133. {
  2134.     switch (fMinor)
  2135.     {
  2136.     case rtfFNAlt:
  2137.         break;
  2138.     }
  2139. }
  2140.  
  2141.  
  2142. void DRTFprocess::KeyCodeAttr()
  2143. {
  2144.     switch (fMinor)
  2145.     {
  2146.     case rtfAltKey:
  2147.         break;
  2148.     case rtfShiftKey:
  2149.         break;
  2150.     case rtfControlKey:
  2151.         break;
  2152.     case rtfFunctionKey:
  2153.         break;
  2154.     }
  2155. }
  2156.  
  2157.  
  2158. void DRTFprocess::ACharAttr()
  2159. {
  2160.     switch (fMinor)
  2161.     {
  2162.     case rtfACBold:
  2163.         break;
  2164.     case rtfACAllCaps:
  2165.         break;
  2166.     case rtfACForeColor:
  2167.         break;
  2168.     case rtfACSubScript:
  2169.         break;
  2170.     case rtfACExpand:
  2171.         break;
  2172.     case rtfACFontNum:
  2173.         break;
  2174.     case rtfACFontSize:
  2175.         break;
  2176.     case rtfACItalic:
  2177.         break;
  2178.     case rtfACLanguage:
  2179.         break;
  2180.     case rtfACOutline:
  2181.         break;
  2182.     case rtfACSmallCaps:
  2183.         break;
  2184.     case rtfACShadow:
  2185.         break;
  2186.     case rtfACStrikeThru:
  2187.         break;
  2188.     case rtfACUnderline:
  2189.         break;
  2190.     case rtfACDotUnderline:
  2191.         break;
  2192.     case rtfACDbUnderline:
  2193.         break;
  2194.     case rtfACNoUnderline:
  2195.         break;
  2196.     case rtfACWordUnderline:
  2197.         break;
  2198.     case rtfACSuperScript:
  2199.         break;
  2200.     }
  2201. }
  2202.  
  2203.  
  2204. void DRTFprocess::FontAttr()
  2205. {
  2206.     switch (fMinor)
  2207.     {
  2208.     case rtfFontCharSet:
  2209.         break;
  2210.     case rtfFontPitch:
  2211.         break;
  2212.     case rtfFontCodePage:
  2213.         break;
  2214.     case rtfFTypeNil:
  2215.         break;
  2216.     case rtfFTypeTrueType:
  2217.         break;
  2218.     }
  2219. }
  2220.  
  2221.  
  2222. void DRTFprocess::FileAttr()
  2223. {
  2224.     switch (fMinor)
  2225.     {
  2226.     case rtfFileNum:
  2227.         break;
  2228.     case rtfFileRelPath:
  2229.         break;
  2230.     case rtfFileOSNum:
  2231.         break;
  2232.     }
  2233. }
  2234.  
  2235.  
  2236. void DRTFprocess::FileSource()
  2237. {
  2238.     switch (fMinor)
  2239.     {
  2240.     case rtfSrcMacintosh:
  2241.         break;
  2242.     case rtfSrcDOS:
  2243.         break;
  2244.     case rtfSrcNTFS:
  2245.         break;
  2246.     case rtfSrcHPFS:
  2247.         break;
  2248.     case rtfSrcNetwork:
  2249.         break;
  2250.     }
  2251. }
  2252.  
  2253.  
  2254. void DRTFprocess::DrawAttr()
  2255. {
  2256.     switch (fMinor)
  2257.     {
  2258.     case rtfDrawLock:
  2259.         break;
  2260.     case rtfDrawPageRelX:
  2261.         break;
  2262.     case rtfDrawColumnRelX:
  2263.         break;
  2264.     case rtfDrawMarginRelX:
  2265.         break;
  2266.     case rtfDrawPageRelY:
  2267.         break;
  2268.     case rtfDrawColumnRelY:
  2269.         break;
  2270.     case rtfDrawMarginRelY:
  2271.         break;
  2272.     case rtfDrawHeight:
  2273.         break;
  2274.     case rtfDrawBeginGroup:
  2275.         break;
  2276.     case rtfDrawGroupCount:
  2277.         break;
  2278.     case rtfDrawEndGroup:
  2279.         break;
  2280.     case rtfDrawArc:
  2281.         break;
  2282.     case rtfDrawCallout:
  2283.         break;
  2284.     case rtfDrawEllipse:
  2285.         break;
  2286.     case rtfDrawLine:
  2287.         break;
  2288.     case rtfDrawPolygon:
  2289.         break;
  2290.     case rtfDrawPolyLine:
  2291.         break;
  2292.     case rtfDrawRect:
  2293.         break;
  2294.     case rtfDrawTextBox:
  2295.         break;
  2296.     case rtfDrawOffsetX:
  2297.         break;
  2298.     case rtfDrawSizeX:
  2299.         break;
  2300.     case rtfDrawOffsetY:
  2301.         break;
  2302.     case rtfDrawSizeY:
  2303.         break;
  2304.     case rtfCOAngle:
  2305.         break;
  2306.     case rtfCOAccentBar:
  2307.         break;
  2308.     case rtfCOBestFit:
  2309.         break;
  2310.     case rtfCOBorder:
  2311.         break;
  2312.     case rtfCOAttachAbsDist:
  2313.         break;
  2314.     case rtfCOAttachBottom:
  2315.         break;
  2316.     case rtfCOAttachCenter:
  2317.         break;
  2318.     case rtfCOAttachTop:
  2319.         break;
  2320.     case rtfCOLength:
  2321.         break;
  2322.     case rtfCONegXQuadrant:
  2323.         break;
  2324.     case rtfCONegYQuadrant:
  2325.         break;
  2326.     case rtfCOOffset:
  2327.         break;
  2328.     case rtfCOAttachSmart:
  2329.         break;
  2330.     case rtfCODoubleLine:
  2331.         break;
  2332.     case rtfCORightAngle:
  2333.         break;
  2334.     case rtfCOSingleLine:
  2335.         break;
  2336.     case rtfCOTripleLine:
  2337.         break;
  2338.     case rtfDrawTextBoxMargin:
  2339.         break;
  2340.     case rtfDrawTextBoxText:
  2341.         break;
  2342.     case rtfDrawRoundRect:
  2343.         break;
  2344.     case rtfDrawPointX:
  2345.         break;
  2346.     case rtfDrawPointY:
  2347.         break;
  2348.     case rtfDrawPolyCount:
  2349.         break;
  2350.     case rtfDrawArcFlipX:
  2351.         break;
  2352.     case rtfDrawArcFlipY:
  2353.         break;
  2354.     case rtfDrawLineBlue:
  2355.         break;
  2356.     case rtfDrawLineGreen:
  2357.         break;
  2358.     case rtfDrawLineRed:
  2359.         break;
  2360.     case rtfDrawLinePalette:
  2361.         break;
  2362.     case rtfDrawLineDashDot:
  2363.         break;
  2364.     case rtfDrawLineDashDotDot:
  2365.         break;
  2366.     case rtfDrawLineDash:
  2367.         break;
  2368.     case rtfDrawLineDot:
  2369.         break;
  2370.     case rtfDrawLineGray:
  2371.         break;
  2372.     case rtfDrawLineHollow:
  2373.         break;
  2374.     case rtfDrawLineSolid:
  2375.         break;
  2376.     case rtfDrawLineWidth:
  2377.         break;
  2378.     case rtfDrawHollowEndArrow:
  2379.         break;
  2380.     case rtfDrawEndArrowLength:
  2381.         break;
  2382.     case rtfDrawSolidEndArrow:
  2383.         break;
  2384.     case rtfDrawEndArrowWidth:
  2385.         break;
  2386.     case rtfDrawHollowStartArrow:
  2387.         break;
  2388.     case rtfDrawStartArrowLength:
  2389.         break;
  2390.     case rtfDrawSolidStartArrow:
  2391.         break;
  2392.     case rtfDrawStartArrowWidth:
  2393.         break;
  2394.     case rtfDrawBgFillBlue:
  2395.         break;
  2396.     case rtfDrawBgFillGreen:
  2397.         break;
  2398.     case rtfDrawBgFillRed:
  2399.         break;
  2400.     case rtfDrawBgFillPalette:
  2401.         break;
  2402.     case rtfDrawBgFillGray:
  2403.         break;
  2404.     case rtfDrawFgFillBlue:
  2405.         break;
  2406.     case rtfDrawFgFillGreen:
  2407.         break;
  2408.     case rtfDrawFgFillRed:
  2409.         break;
  2410.     case rtfDrawFgFillPalette:
  2411.         break;
  2412.     case rtfDrawFgFillGray:
  2413.         break;
  2414.     case rtfDrawFillPatIndex:
  2415.         break;
  2416.     case rtfDrawShadow:
  2417.         break;
  2418.     case rtfDrawShadowXOffset:
  2419.         break;
  2420.     case rtfDrawShadowYOffset:
  2421.         break;
  2422.     }
  2423. }
  2424.  
  2425.  
  2426. void DRTFprocess::IndexAttr()
  2427. {
  2428.     switch (fMinor)
  2429.     {
  2430.     case rtfIndexNumber:
  2431.         break;
  2432.     case rtfIndexBold:
  2433.         break;
  2434.     case rtfIndexItalic:
  2435.         break;
  2436.     }
  2437. }
  2438.  
  2439.  
  2440. void DRTFprocess::SelectLanguage()
  2441. {
  2442.     switch (fParam)
  2443.     {
  2444.     case rtfLangNoLang:
  2445.         break;
  2446.     case rtfLangAlbanian:
  2447.         break;
  2448.     case rtfLangArabic:
  2449.         break;
  2450.     case rtfLangBahasa:
  2451.         break;
  2452.     case rtfLangBelgianDutch:
  2453.         break;
  2454.     case rtfLangBelgianFrench:
  2455.         break;
  2456.     case rtfLangBrazilianPortuguese:
  2457.         break;
  2458.     case rtfLangBulgarian:
  2459.         break;
  2460.     case rtfLangCatalan:
  2461.         break;
  2462.     case rtfLangLatinCroatoSerbian:
  2463.         break;
  2464.     case rtfLangCzech:
  2465.         break;
  2466.     case rtfLangDanish:
  2467.         break;
  2468.     case rtfLangDutch:
  2469.         break;
  2470.     case rtfLangAustralianEnglish:
  2471.         break;
  2472.     case rtfLangUKEnglish:
  2473.         break;
  2474.     case rtfLangUSEnglish:
  2475.         break;
  2476.     case rtfLangFinnish:
  2477.         break;
  2478.     case rtfLangFrench:
  2479.         break;
  2480.     case rtfLangCanadianFrench:
  2481.         break;
  2482.     case rtfLangGerman:
  2483.         break;
  2484.     case rtfLangGreek:
  2485.         break;
  2486.     case rtfLangHebrew:
  2487.         break;
  2488.     case rtfLangHungarian:
  2489.         break;
  2490.     case rtfLangIcelandic:
  2491.         break;
  2492.     case rtfLangItalian:
  2493.         break;
  2494.     case rtfLangJapanese:
  2495.         break;
  2496.     case rtfLangKorean:
  2497.         break;
  2498.     case rtfLangBokmalNorwegian:
  2499.         break;
  2500.     case rtfLangNynorskNorwegian:
  2501.         break;
  2502.     case rtfLangPolish:
  2503.         break;
  2504.     case rtfLangPortuguese:
  2505.         break;
  2506.     case rtfLangRhaetoRomanic:
  2507.         break;
  2508.     case rtfLangRomanian:
  2509.         break;
  2510.     case rtfLangRussian:
  2511.         break;
  2512.     case rtfLangCyrillicSerboCroatian:
  2513.         break;
  2514.     case rtfLangSimplifiedChinese:
  2515.         break;
  2516.     case rtfLangSlovak:
  2517.         break;
  2518.     case rtfLangCastilianSpanish:
  2519.         break;
  2520.     case rtfLangMexicanSpanish:
  2521.         break;
  2522.     case rtfLangSwedish:
  2523.         break;
  2524.     case rtfLangSwissFrench:
  2525.         break;
  2526.     case rtfLangSwissGerman:
  2527.         break;
  2528.     case rtfLangSwissItalian:
  2529.         break;
  2530.     case rtfLangThai:
  2531.         break;
  2532.     case rtfLangTraditionalChinese:
  2533.         break;
  2534.     case rtfLangTurkish:
  2535.         break;
  2536.     case rtfLangUrdu:
  2537.         break;
  2538.     }
  2539. }
  2540.  
  2541.